home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1997 May / EnigmA AMIGA RUN 18 (1997)(G.R. Edizioni)(IT)[!][issue 1997-05][EAR-CD II].iso / ghost / gs403src_gs.lha / gs4.03 / gsparam.c < prev    next >
C/C++ Source or Header  |  1995-10-04  |  11KB  |  370 lines
  1. /* Copyright (C) 1995 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* gsparam.c */
  20. /* Default implementation of parameter lists */
  21. #include "memory_.h"
  22. #include "string_.h"
  23. #include "gx.h"
  24. #include "gserrors.h"
  25. #include "gsparam.h"
  26. #include "gsstruct.h"
  27.  
  28. /* Forward references */
  29. typedef union c_param_value_s c_param_value;
  30. /*typedef struct gs_c_param_s gs_c_param;*/    /* in gsparam.h */
  31.  
  32. /* Define the GC type for a parameter list. */
  33. private_st_c_param_list();
  34.  
  35. /* Define a union type for parameter values. */
  36. union c_param_value_s {
  37.     bool b;
  38.     long l;
  39.     float f;
  40.     gs_param_string s;
  41.     gs_param_int_array ia;
  42.     gs_param_float_array fa;
  43.     gs_param_string_array sa;
  44.     gs_c_param_list d;
  45. };
  46.  
  47. /*
  48.  * Define the parameter list element types.
  49.  * We would like to define:
  50.  *    #define cpt(n, t) ((sizeof(t) << 4) + n)
  51.  *    #define cpt_size(cpt) ((cpt) >> 4)
  52.  * but a bug in the Borland C++ 3.1 compiler causes the enumerated type
  53.  * never to get defined if we do this.  Instead, we use an ordinary
  54.  * enumeration, and get the sizes from a table.
  55.  */
  56. typedef enum {
  57.     cpt_null, cpt_bool, cpt_long, cpt_float,
  58.     cpt_string, cpt_int_array,
  59.     cpt_float_array, cpt_string_array,
  60.     cpt_dict
  61. } c_param_type;
  62. private const byte c_param_type_sizes[] = {
  63.     0, sizeof(bool), sizeof(long), sizeof(float),
  64.     sizeof(gs_param_string), sizeof(gs_param_int_array),
  65.     sizeof(gs_param_float_array), sizeof(gs_param_string_array),
  66.     sizeof(gs_c_param_list)
  67. };
  68. #define cpt_size(cpt) (c_param_type_sizes[(int)cpt])
  69.  
  70. /* Define a parameter list element. */
  71. struct gs_c_param_s {
  72.     gs_c_param *next;
  73.     gs_param_name key;
  74.     c_param_value value;
  75.     c_param_type type;
  76. };
  77. /* Parameter values aren't really simple, */
  78. /* but since parameter lists are transient, it doesn't matter. */
  79. gs_private_st_ptrs1(st_c_param, gs_c_param, "gs_c_param",
  80.   c_param_enum_ptrs, c_param_reloc_ptrs, next);
  81.  
  82. /* ================ Utilities ================ */
  83.  
  84. #define cplist ((gs_c_param_list *)plist)
  85.  
  86. /* ================ Writing parameters to a list ================ */
  87.  
  88. private param_proc_xmit_null(c_param_write_null);
  89. private param_proc_xmit_bool(c_param_write_bool);
  90. private param_proc_xmit_int(c_param_write_int);
  91. private param_proc_xmit_long(c_param_write_long);
  92. private param_proc_xmit_float(c_param_write_float);
  93. private param_proc_xmit_string(c_param_write_string);
  94. private param_proc_xmit_int_array(c_param_write_int_array);
  95. private param_proc_xmit_float_array(c_param_write_float_array);
  96. private param_proc_xmit_string_array(c_param_write_string_array);
  97. private param_proc_begin_xmit_dict(c_param_begin_write_dict);
  98. private param_proc_end_xmit_dict(c_param_end_write_dict);
  99. private param_proc_requested(c_param_requested);
  100. private const gs_param_list_procs c_write_procs = {
  101.     c_param_write_null,
  102.     c_param_write_bool,
  103.     c_param_write_int,
  104.     c_param_write_long,
  105.     c_param_write_float,
  106.     c_param_write_string,
  107.     c_param_write_string,        /* name = string */
  108.     c_param_write_int_array,
  109.     c_param_write_float_array,
  110.     c_param_write_string_array,
  111.     c_param_write_string_array,    /* name = string */
  112.     c_param_begin_write_dict,
  113.     c_param_end_write_dict,
  114.     c_param_requested
  115. };
  116.  
  117. /* Initialize a list for writing. */
  118. void
  119. gs_c_param_list_write(gs_c_param_list *plist, gs_memory_t *mem)
  120. {    plist->procs = &c_write_procs;
  121.     plist->memory = mem;
  122.     plist->head = 0;
  123.     plist->count = 0;
  124. }
  125.  
  126. /* Release a list. */
  127. void
  128. gs_c_param_list_release(gs_c_param_list *plist)
  129. {    gs_c_param *pparam;
  130.     while ( (pparam = plist->head) != 0 )
  131.       { gs_c_param *next = pparam->next;
  132.         if ( pparam->type == cpt_dict )
  133.           gs_c_param_list_release(&pparam->value.d);
  134.         gs_free_object(plist->memory, pparam, "gs_c_param_list_release");
  135.         plist->head = next;
  136.         plist->count--;
  137.       }
  138. }
  139.  
  140. /* Generic routine for writing a parameter to a list. */
  141. private int
  142. c_param_write(gs_c_param_list *plist, gs_param_name pkey, void *pvalue,
  143.   c_param_type type)
  144. {    gs_c_param *pparam =
  145.       gs_alloc_struct(plist->memory, gs_c_param, &st_c_param,
  146.               "c_param_write");
  147.     if ( pparam == 0 )
  148.       return_error(gs_error_VMerror);
  149.     pparam->next = plist->head;
  150.     pparam->key = pkey;
  151.     memcpy(&pparam->value, pvalue, cpt_size(type));
  152.     pparam->type = type;
  153.     plist->head = pparam;
  154.     plist->count++;
  155.     return 0;
  156. }
  157.  
  158. /* Individual writing routines. */
  159. #define cpw(pvalue, type)\
  160.   c_param_write(cplist, pkey, pvalue, type)
  161. private int
  162. c_param_write_null(gs_param_list *plist, gs_param_name pkey)
  163. {    return cpw(NULL, cpt_null);
  164. }
  165. private int
  166. c_param_write_bool(gs_param_list *plist, gs_param_name pkey, bool *pvalue)
  167. {    return cpw(pvalue, cpt_bool);
  168. }
  169. private int
  170. c_param_write_int(gs_param_list *plist, gs_param_name pkey, int *pvalue)
  171. {    long l = *pvalue;
  172.     return cpw(&l, cpt_long);
  173. }
  174. private int
  175. c_param_write_long(gs_param_list *plist, gs_param_name pkey, long *pvalue)
  176. {    return cpw(pvalue, cpt_long);
  177. }
  178. private int
  179. c_param_write_float(gs_param_list *plist, gs_param_name pkey, float *pvalue)
  180. {    return cpw(pvalue, cpt_float);
  181. }
  182. private int
  183. c_param_write_string(gs_param_list *plist, gs_param_name pkey,
  184.   gs_param_string *pvalue)
  185. {    return cpw(pvalue, cpt_string);
  186. }
  187. private int
  188. c_param_write_int_array(gs_param_list *plist, gs_param_name pkey,
  189.   gs_param_int_array *pvalue)
  190. {    return cpw(pvalue, cpt_int_array);
  191. }
  192. private int
  193. c_param_write_float_array(gs_param_list *plist, gs_param_name pkey,
  194.   gs_param_float_array *pvalue)
  195. {    return cpw(pvalue, cpt_float_array);
  196. }
  197. private int
  198. c_param_write_string_array(gs_param_list *plist, gs_param_name pkey,
  199.   gs_param_string_array *pvalue)
  200. {    return cpw(pvalue, cpt_string_array);
  201. }
  202. private int
  203. c_param_begin_write_dict(gs_param_list *plist, gs_param_name pkey,
  204.   gs_param_dict *pvalue, bool int_keys)
  205. {    gs_c_param_list *dlist =
  206.       gs_alloc_struct(cplist->memory, gs_c_param_list, &st_c_param_list,
  207.               "c_param_begin_write_dict");
  208.     if ( dlist == 0 )
  209.       return_error(gs_error_VMerror);
  210.     gs_c_param_list_write(dlist, cplist->memory);
  211.     pvalue->list = (gs_param_list *)dlist;
  212.     return 0;
  213. }
  214. private int
  215. c_param_end_write_dict(gs_param_list *plist, gs_param_name pkey,
  216.   gs_param_dict *pvalue)
  217. {    return cpw(pvalue->list, cpt_dict);
  218. }
  219.  
  220. /* Other procedures */
  221. private bool
  222. c_param_requested(const gs_param_list *plist, gs_param_name pkey)
  223. {    return true;
  224. }
  225.  
  226. /* ================ Reading from a list to parameters ================ */
  227.  
  228. private param_proc_xmit_null(c_param_read_null);
  229. private param_proc_xmit_bool(c_param_read_bool);
  230. private param_proc_xmit_int(c_param_read_int);
  231. private param_proc_xmit_long(c_param_read_long);
  232. private param_proc_xmit_float(c_param_read_float);
  233. private param_proc_xmit_string(c_param_read_string);
  234. private param_proc_xmit_int_array(c_param_read_int_array);
  235. private param_proc_xmit_float_array(c_param_read_float_array);
  236. private param_proc_xmit_string_array(c_param_read_string_array);
  237. private param_proc_begin_xmit_dict(c_param_begin_read_dict);
  238. private param_proc_end_xmit_dict(c_param_end_read_dict);
  239. private param_proc_get_policy(c_param_read_get_policy);
  240. private param_proc_signal_error(c_param_read_signal_error);
  241. private param_proc_commit(c_param_read_commit);
  242. private const gs_param_list_procs c_read_procs = {
  243.     c_param_read_null,
  244.     c_param_read_bool,
  245.     c_param_read_int,
  246.     c_param_read_long,
  247.     c_param_read_float,
  248.     c_param_read_string,
  249.     c_param_read_string,        /* name = string */
  250.     c_param_read_int_array,
  251.     c_param_read_float_array,
  252.     c_param_read_string_array,
  253.     c_param_read_string_array,    /* name = string */
  254.     c_param_begin_read_dict,
  255.     c_param_end_read_dict,
  256.     NULL,                /* requested */
  257.     c_param_read_get_policy,
  258.     c_param_read_signal_error,
  259.     c_param_read_commit
  260. };
  261.  
  262. /* Switch a list from writing to reading. */
  263. void
  264. gs_c_param_list_read(gs_c_param_list *plist)
  265. {    plist->procs = &c_read_procs;
  266. }
  267.  
  268. /* Generic routine for reading a parameter from a list. */
  269. private gs_c_param *
  270. c_param_find(gs_c_param_list *plist, gs_param_name pkey)
  271. {    gs_c_param *pparam = plist->head;
  272.     for ( ; pparam != 0; pparam = pparam->next )
  273.       if ( !strcmp(pparam->key, pkey) )
  274.         return pparam;
  275.     return 0;
  276. }
  277. private int
  278. c_param_read(gs_c_param_list *plist, gs_param_name pkey, void *pvalue,
  279.   c_param_type type)
  280. {    gs_c_param *pparam = c_param_find(plist, pkey);
  281.     if ( pparam == 0 )
  282.       return 1;
  283.     if ( pparam->type != type )
  284.       return_error(gs_error_typecheck);
  285.     memcpy(pvalue, &pparam->value, cpt_size(type));
  286.     return 0;
  287. }
  288.  
  289. /* Individual reading routines. */
  290. #define cpr(pvalue, type)\
  291.   c_param_read(cplist, pkey, pvalue, type)
  292. private int
  293. c_param_read_null(gs_param_list *plist, gs_param_name pkey)
  294. {    return cpr(NULL, cpt_null);
  295. }
  296. private int
  297. c_param_read_bool(gs_param_list *plist, gs_param_name pkey, bool *pvalue)
  298. {    return cpr(pvalue, cpt_bool);
  299. }
  300. private int
  301. c_param_read_int(gs_param_list *plist, gs_param_name pkey, int *pvalue)
  302. {    long l;
  303.     int code = cpr(&l, cpt_long);
  304.     if ( code == 0 )
  305.       { if ( l < min_int || l > max_int )
  306.           return_error(gs_error_rangecheck);
  307.       }
  308.     return code;
  309. }
  310. private int
  311. c_param_read_long(gs_param_list *plist, gs_param_name pkey, long *pvalue)
  312. {    return cpr(pvalue, cpt_long);
  313. }
  314. private int
  315. c_param_read_float(gs_param_list *plist, gs_param_name pkey, float *pvalue)
  316. {    return cpr(pvalue, cpt_float);
  317. }
  318. private int
  319. c_param_read_string(gs_param_list *plist, gs_param_name pkey,
  320.   gs_param_string *pvalue)
  321. {    return cpr(pvalue, cpt_string);
  322. }
  323. private int
  324. c_param_read_int_array(gs_param_list *plist, gs_param_name pkey,
  325.   gs_param_int_array *pvalue)
  326. {    return cpr(pvalue, cpt_int_array);
  327. }
  328. private int
  329. c_param_read_float_array(gs_param_list *plist, gs_param_name pkey,
  330.   gs_param_float_array *pvalue)
  331. {    return cpr(pvalue, cpt_float_array);
  332. }
  333. private int
  334. c_param_read_string_array(gs_param_list *plist, gs_param_name pkey,
  335.   gs_param_string_array *pvalue)
  336. {    return cpr(pvalue, cpt_string_array);
  337. }
  338. private int
  339. c_param_begin_read_dict(gs_param_list *plist, gs_param_name pkey,
  340.   gs_param_dict *pvalue, bool int_keys)
  341. {    gs_c_param *pparam = c_param_find(cplist, pkey);
  342.     if ( pparam == 0 )
  343.       return 1;
  344.     if ( pparam->type != cpt_dict )
  345.       return_error(gs_error_typecheck);
  346.     gs_c_param_list_read(&pparam->value.d);
  347.     pvalue->list = (gs_param_list *)&pparam->value.d;
  348.     pvalue->size = pparam->value.d.count;
  349.     return 0;
  350. }
  351. private int
  352. c_param_end_read_dict(gs_param_list *plist, gs_param_name pkey,
  353.   gs_param_dict *pvalue)
  354. {    return 0;
  355. }
  356.  
  357. /* Other procedures */
  358. private int
  359. c_param_read_get_policy(gs_param_list *plist, gs_param_name pkey)
  360. {    return gs_param_policy_ignore;
  361. }
  362. private int
  363. c_param_read_signal_error(gs_param_list *plist, gs_param_name pkey, int code)
  364. {    return code;
  365. }
  366. private int
  367. c_param_read_commit(gs_param_list *plist)
  368. {    return 0;
  369. }
  370.